﻿#define  _CRT_SECURE_NO_WARNINGS 1
#if 0
#include<iostream>
using namespace std;
class Stack
{
public:
	// 成员函数​
	void Init(int n = 4)
	{
		array = (int*)malloc(sizeof(int) * n);
		if (nullptr == array)
		{
			perror("malloc申请空间失败");
			return;
		}
		capacity = n;
		top = 0;
	}
	void Push(int x)
	{
		// ...扩容​
		array[top++] = x;
	}

	int Top()
	{
		return array[top - 1];
	}
	void Destroy()
	{
		free(array);
		array = nullptr;
		top = capacity = 0;
	}
private:
	// 成员变量​
	int* array;
	size_t capacity;
	size_t top;
}; // 分号不能省略​
int main()
{
	Stack st;
	st.Init();
	st.Push(1);
	st.Push(2);
	cout << st.Top() << endl;
	st.Destroy();
	return 0;
}

#include<iostream>
using namespace std;
class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	// 这里只是声明，没有开空间​
	int _year;
	int _month;
	int _day;
};
void test()
{
	// Date类实例化出对象d1和d2​
	Date d1;
	Date d2;
	d1.Init(2024, 3, 31);
	d1.Print();
	d2.Init(2024, 7, 5);
	d2.Print();

}

// 计算一下A/B/C实例化的对象是多大？​
class A
{
public:
	void Print()
	{
		cout << _ch << endl;
	}
private:
	char _ch;
	int _i;
};
class B
{
public:
	void Print()
	{
		//...
	}
};
class C
{};
int main()
{
	A a;
	B b;
	C c;
	cout << sizeof(a) << endl;
	cout << sizeof(b) << endl;
	cout << sizeof(c) << endl;
	return 0;
}


#include<iostream>
using namespace std;
class A
{
public:
	void Print()
	{
		cout << "A::Print()" << endl;
		cout << _a << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->Print();
	return 0;
}


#include<iostream>
using namespace std;
class Date
{
public:

	// 1.无参构造函数​
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	// 2.带参构造函数​
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	
	 //3.全缺省构造函数​
	/*
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	*/
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	// 如果留下三个构造中的第三个带参构造，第一个和第二个注释掉​
	// 编译报错：error C2512: “Date”: 没有合适的默认构造函数可用​
	Date d1; // 调用默认构造函数​
	Date d2(2025, 1, 1); // 调用带参的构造函数​
	// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则编译器无法​
	// 区分这里是函数声明还是实例化对象​
	// warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)​
	Date d3();
	d1.Print();
	d2.Print();
	return 0;
}


#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
private:
	STDataType * _a;
	size_t _capacity;
	size_t _top;
};

// 两个Stack实现队列​
class MyQueue
{
public:
	//编译器默认生成MyQueue的构造函数调用了Stack的构造，完成了两个成员的初始化​
private:
	Stack pushst;
	Stack popst;
	int size;
};
int main()
{
	MyQueue mq;
	return 0;
}



#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
// 两个Stack实现队列​
class MyQueue
{
public:
	//编译器默认生成MyQueue的析构函数调用了Stack的析构，释放的Stack内部的资源​
	// 显示写析构，也会自动调用Stack的析构​
	/*~MyQueue()
	{
	}*/
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	Stack st;
	MyQueue mq;
	return 0;
}




#include<iostream>
using namespace std;
// 用最新加了构造和析构的C++版本Stack实现​
bool isValid(const char* s) {
	Stack st;
	while (*s)
	{
		if (*s == '[' || *s == '(' || *s == '{')
		{
			st.Push(*s);
		}
		else
		{
			// 右括号比左括号多，数量匹配问题​
			if (st.Empty())
			{
				return false;
			}
			// 栈里面取左括号​
			char top = st.Top();
			st.Pop();
			// 顺序不匹配​
			if ((*s == ']' && top != '[')
				|| (*s == '}' && top != '{')
				|| (*s == ')' && top != '('))
			{
				return false;
			}
		}
		++s;
	}
	// 栈为空，返回真，说明数量都匹配 左括号多，右括号少匹配问题​
	return st.Empty();
}

// 用之前C版本Stack实现​
bool isValid(const char* s) {
	ST st;
	STInit(&st);
	while (*s)
	{
		// 左括号入栈​
		if (*s == '(' || *s == '[' || *s == '{')
		{
			STPush(&st, *s);
		}
		else // 右括号取栈顶左括号尝试匹配​
		{
			if (STEmpty(&st))
			{
				STDestroy(&st);
				return false;
			}
			char top = STTop(&st);
			STPop(&st);
			// 不匹配​
			if ((top == '(' && *s != ')')
				|| (top == '{' && *s != '}')
				|| (top == '[' && *s != ']'))
			{
				STDestroy(&st);
				return false;
			}
		}
		++s;
	}
	// 栈不为空，说明左括号比右括号多，数量不匹配​
	bool ret = STEmpty(&st);
	STDestroy(&st);
	return ret;
}
int main()
{
	cout << isValid("[()][]") << endl;
	cout << isValid("[(])[]") << endl;
	return 0;
}

#endif

#include<iostream>
using namespace std;
// 编译报错：“operator +”必须至少有一个类类型的形参​
/*
int operator+(int x, int y)
{
	return x - y;
}
*/
class A
{
public:
	void func()
	{
		cout << "A::func()" << endl;
	}
};
typedef void(A::* PF)(); //成员函数指针类型​
int main()
{
	// C++规定成员函数要加&才能取到函数指针​
	PF pf = &A::func;
	A obj;//定义ob类对象temp​
	// 对象调用成员函数指针时，使用.*运算符​
	(obj.*pf)();
	return 0;
}










